home *** CD-ROM | disk | FTP | other *** search
- # Source Generated with Decompyle++
- # File: in.pyc (Python 2.4)
-
- import unittest
- import os
- from test import test_support
- import warnings
- warnings.filterwarnings('ignore', category = DeprecationWarning, message = '.*complex divmod.*are deprecated')
- from random import random
-
- class ComplexTest(unittest.TestCase):
-
- def assertAlmostEqual(self, a, b):
- if isinstance(a, complex):
- if isinstance(b, complex):
- unittest.TestCase.assertAlmostEqual(self, a.real, b.real)
- unittest.TestCase.assertAlmostEqual(self, a.imag, b.imag)
- else:
- unittest.TestCase.assertAlmostEqual(self, a.real, b)
- unittest.TestCase.assertAlmostEqual(self, a.imag, 0.0)
- elif isinstance(b, complex):
- unittest.TestCase.assertAlmostEqual(self, a, b.real)
- unittest.TestCase.assertAlmostEqual(self, 0.0, b.imag)
- else:
- unittest.TestCase.assertAlmostEqual(self, a, b)
-
-
- def assertCloseAbs(self, x, y, eps = 1.0000000000000001e-09):
- '''Return true iff floats x and y "are close"'''
- if abs(x) > abs(y):
- x = y
- y = x
-
- if y == 0:
- return abs(x) < eps
-
- if x == 0:
- return abs(y) < eps
-
- self.assert_(abs((x - y) / y) < eps)
-
-
- def assertClose(self, x, y, eps = 1.0000000000000001e-09):
- '''Return true iff complexes x and y "are close"'''
- self.assertCloseAbs(x.real, y.real, eps)
- self.assertCloseAbs(x.imag, y.imag, eps)
-
-
- def assertIs(self, a, b):
- self.assert_(a is b)
-
-
- def check_div(self, x, y):
- '''Compute complex z=x*y, and check that z/x==y and z/y==x.'''
- z = x * y
- if x != 0:
- q = z / x
- self.assertClose(q, y)
- q = z.__div__(x)
- self.assertClose(q, y)
- q = z.__truediv__(x)
- self.assertClose(q, y)
-
- if y != 0:
- q = z / y
- self.assertClose(q, x)
- q = z.__div__(y)
- self.assertClose(q, x)
- q = z.__truediv__(y)
- self.assertClose(q, x)
-
-
-
- def test_div(self):
- simple_real = [ float(i) for i in xrange(-5, 6) ]
- simple_complex = [ complex(x, y) for x in simple_real for y in simple_real ]
- for x in simple_complex:
- for y in simple_complex:
- self.check_div(x, y)
-
-
- self.check_div(complex(9.9999999999999997e+199, 9.9999999999999997e+199), 1 + (0.0+0.0j))
- self.check_div(complex(9.9999999999999998e-201, 9.9999999999999998e-201), 1 + (0.0+0.0j))
- for i in xrange(100):
- self.check_div(complex(random(), random()), complex(random(), random()))
-
- self.assertRaises(ZeroDivisionError, complex.__div__, 1 + (0.0+1.0j), 0 + (0.0+0.0j))
-
-
- def test_truediv(self):
- self.assertAlmostEqual(complex.__truediv__(2 + (0.0+0.0j), 1 + (0.0+1.0j)), 1 - (0.0+1.0j))
- self.assertRaises(ZeroDivisionError, complex.__truediv__, 1 + (0.0+1.0j), 0 + (0.0+0.0j))
-
-
- def test_floordiv(self):
- self.assertAlmostEqual(complex.__floordiv__(3 + (0.0+0.0j), 1.5 + (0.0+0.0j)), 2)
- self.assertRaises(ZeroDivisionError, complex.__floordiv__, 3 + (0.0+0.0j), 0 + (0.0+0.0j))
-
-
- def test_coerce(self):
- self.assertRaises(OverflowError, complex.__coerce__, 1 + (0.0+1.0j), 0x1L << 10000)
-
-
- def test_richcompare(self):
- self.assertRaises(OverflowError, complex.__eq__, 1 + (0.0+1.0j), 0x1L << 10000)
- self.assertEqual(complex.__lt__(1 + (0.0+1.0j), None), NotImplemented)
- self.assertIs(complex.__eq__(1 + (0.0+1.0j), 1 + (0.0+1.0j)), True)
- self.assertIs(complex.__eq__(1 + (0.0+1.0j), 2 + (0.0+2.0j)), False)
- self.assertIs(complex.__ne__(1 + (0.0+1.0j), 1 + (0.0+1.0j)), False)
- self.assertIs(complex.__ne__(1 + (0.0+1.0j), 2 + (0.0+2.0j)), True)
- self.assertRaises(TypeError, complex.__lt__, 1 + (0.0+1.0j), 2 + (0.0+2.0j))
- self.assertRaises(TypeError, complex.__le__, 1 + (0.0+1.0j), 2 + (0.0+2.0j))
- self.assertRaises(TypeError, complex.__gt__, 1 + (0.0+1.0j), 2 + (0.0+2.0j))
- self.assertRaises(TypeError, complex.__ge__, 1 + (0.0+1.0j), 2 + (0.0+2.0j))
-
-
- def test_mod(self):
- self.assertRaises(ZeroDivisionError, (1 + (0.0+1.0j)).__mod__, 0 + (0.0+0.0j))
- a = 3.3300000000000001 + (0.0+4.4299999999999997j)
-
- try:
- a % 0
- except ZeroDivisionError:
- pass
-
- self.fail("modulo parama can't be 0")
-
-
- def test_divmod(self):
- self.assertRaises(ZeroDivisionError, divmod, 1 + (0.0+1.0j), 0 + (0.0+0.0j))
-
-
- def test_pow(self):
- self.assertAlmostEqual(pow(1 + (0.0+1.0j), 0 + (0.0+0.0j)), 1.0)
- self.assertAlmostEqual(pow(0 + (0.0+0.0j), 2 + (0.0+0.0j)), 0.0)
- self.assertRaises(ZeroDivisionError, pow, 0 + (0.0+0.0j), (0.0+1.0j))
- self.assertAlmostEqual(pow((0.0+1.0j), -1), 1 / (0.0+1.0j))
- self.assertAlmostEqual(pow((0.0+1.0j), 200), 1)
- self.assertRaises(ValueError, pow, 1 + (0.0+1.0j), 1 + (0.0+1.0j), 1 + (0.0+1.0j))
- a = 3.3300000000000001 + (0.0+4.4299999999999997j)
- self.assertEqual(a ** (0.0+0.0j), 1)
- self.assertEqual(a ** 0.0 + (0.0+0.0j), 1)
- self.assertEqual((0.0+3.0j) ** (0.0+0.0j), 1)
- self.assertEqual((0.0+3.0j) ** 0, 1)
-
- try:
- (0.0+0.0j) ** a
- except ZeroDivisionError:
- pass
-
- self.fail('should fail 0.0 to negative or complex power')
-
- try:
- (0.0+0.0j) ** (3 - (0.0+2.0j))
- except ZeroDivisionError:
- pass
-
- self.fail('should fail 0.0 to negative or complex power')
- self.assertEqual(a ** 105, a ** 105)
- self.assertEqual(a ** -105, a ** -105)
- self.assertEqual(a ** -30, a ** -30)
- self.assertEqual((0.0+0.0j) ** 0, 1)
- b = 5.0999999999999996 + (0.0+2.2999999999999998j)
- self.assertRaises(ValueError, pow, a, b, 0)
-
-
- def test_boolcontext(self):
- for i in xrange(100):
- self.assert_(complex(random() + 9.9999999999999995e-07, random() + 9.9999999999999995e-07))
-
- self.assert_(not complex(0.0, 0.0))
-
-
- def test_conjugate(self):
- self.assertClose(complex(5.2999999999999998, 9.8000000000000007).conjugate(), 5.2999999999999998 - (0.0+9.8000000000000007j))
-
-
- def test_constructor(self):
-
- class OS:
-
- def __init__(self, value):
- self.value = value
-
-
- def __complex__(self):
- return self.value
-
-
-
- class NS(object):
-
- def __init__(self, value):
- self.value = value
-
-
- def __complex__(self):
- return self.value
-
-
- self.assertEqual(complex(OS(1 + (0.0+10.0j))), 1 + (0.0+10.0j))
- self.assertEqual(complex(NS(1 + (0.0+10.0j))), 1 + (0.0+10.0j))
- self.assertRaises(TypeError, complex, OS(None))
- self.assertRaises(TypeError, complex, NS(None))
- self.assertAlmostEqual(complex('1+10j'), 1 + (0.0+10.0j))
- self.assertAlmostEqual(complex(10), 10 + (0.0+0.0j))
- self.assertAlmostEqual(complex(10.0), 10 + (0.0+0.0j))
- self.assertAlmostEqual(complex(0xAL), 10 + (0.0+0.0j))
- self.assertAlmostEqual(complex(10 + (0.0+0.0j)), 10 + (0.0+0.0j))
- self.assertAlmostEqual(complex(1, 10), 1 + (0.0+10.0j))
- self.assertAlmostEqual(complex(1, 0xAL), 1 + (0.0+10.0j))
- self.assertAlmostEqual(complex(1, 10.0), 1 + (0.0+10.0j))
- self.assertAlmostEqual(complex(0x1L, 10), 1 + (0.0+10.0j))
- self.assertAlmostEqual(complex(0x1L, 0xAL), 1 + (0.0+10.0j))
- self.assertAlmostEqual(complex(0x1L, 10.0), 1 + (0.0+10.0j))
- self.assertAlmostEqual(complex(1.0, 10), 1 + (0.0+10.0j))
- self.assertAlmostEqual(complex(1.0, 0xAL), 1 + (0.0+10.0j))
- self.assertAlmostEqual(complex(1.0, 10.0), 1 + (0.0+10.0j))
- self.assertAlmostEqual(complex(3.1400000000000001 + (0.0+0.0j)), 3.1400000000000001 + (0.0+0.0j))
- self.assertAlmostEqual(complex(3.1400000000000001), 3.1400000000000001 + (0.0+0.0j))
- self.assertAlmostEqual(complex(314), 314.0 + (0.0+0.0j))
- self.assertAlmostEqual(complex(0x13AL), 314.0 + (0.0+0.0j))
- self.assertAlmostEqual(complex(3.1400000000000001 + (0.0+0.0j), (0.0+0.0j)), 3.1400000000000001 + (0.0+0.0j))
- self.assertAlmostEqual(complex(3.1400000000000001, 0.0), 3.1400000000000001 + (0.0+0.0j))
- self.assertAlmostEqual(complex(314, 0), 314.0 + (0.0+0.0j))
- self.assertAlmostEqual(complex(0x13AL, 0x0L), 314.0 + (0.0+0.0j))
- self.assertAlmostEqual(complex((0.0+0.0j), (0.0+3.1400000000000001j)), -3.1400000000000001 + (0.0+0.0j))
- self.assertAlmostEqual(complex(0.0, (0.0+3.1400000000000001j)), -3.1400000000000001 + (0.0+0.0j))
- self.assertAlmostEqual(complex((0.0+0.0j), 3.1400000000000001), (0.0+3.1400000000000001j))
- self.assertAlmostEqual(complex(0.0, 3.1400000000000001), (0.0+3.1400000000000001j))
- self.assertAlmostEqual(complex('1'), 1 + (0.0+0.0j))
- self.assertAlmostEqual(complex('1j'), (0.0+1.0j))
- self.assertAlmostEqual(complex(), 0)
- self.assertAlmostEqual(complex('-1'), -1)
- self.assertAlmostEqual(complex('+1'), 1)
-
- class complex2(complex):
- pass
-
- self.assertAlmostEqual(complex(complex2(1 + (0.0+1.0j))), 1 + (0.0+1.0j))
- self.assertAlmostEqual(complex(real = 17, imag = 23), 17 + (0.0+23.0j))
- self.assertAlmostEqual(complex(real = 17 + (0.0+23.0j)), 17 + (0.0+23.0j))
- self.assertAlmostEqual(complex(real = 17 + (0.0+23.0j), imag = 23), 17 + (0.0+46.0j))
- self.assertAlmostEqual(complex(real = 1 + (0.0+2.0j), imag = 3 + (0.0+4.0j)), -3 + (0.0+5.0j))
- c = 3.1400000000000001 + (0.0+1.0j)
- self.assert_(complex(c) is c)
- del c
- self.assertRaises(TypeError, complex, '1', '1')
- self.assertRaises(TypeError, complex, 1, '1')
- self.assertEqual(complex(' 3.14+J '), 3.1400000000000001 + (0.0+1.0j))
- if test_support.have_unicode:
- self.assertEqual(complex(unicode(' 3.14+J ')), 3.1400000000000001 + (0.0+1.0j))
-
- self.assertRaises(ValueError, complex, '1+1j\x00j')
- self.assertRaises(TypeError, int, 5 + (0.0+3.0j))
- self.assertRaises(TypeError, long, 5 + (0.0+3.0j))
- self.assertRaises(TypeError, float, 5 + (0.0+3.0j))
- self.assertRaises(ValueError, complex, '')
- self.assertRaises(TypeError, complex, None)
- self.assertRaises(ValueError, complex, '\x00')
- self.assertRaises(TypeError, complex, '1', '2')
- self.assertRaises(TypeError, complex, '1', 42)
- self.assertRaises(TypeError, complex, 1, '2')
- self.assertRaises(ValueError, complex, '1+')
- self.assertRaises(ValueError, complex, '1+1j+1j')
- self.assertRaises(ValueError, complex, '--')
- if test_support.have_unicode:
- self.assertRaises(ValueError, complex, unicode('1' * 500))
- self.assertRaises(ValueError, complex, unicode('x'))
-
-
- class EvilExc(Exception):
- pass
-
-
- class evilcomplex:
-
- def __complex__(self):
- raise EvilExc
-
-
- self.assertRaises(EvilExc, complex, evilcomplex())
-
- class float2:
-
- def __init__(self, value):
- self.value = value
-
-
- def __float__(self):
- return self.value
-
-
- self.assertAlmostEqual(complex(float2(42.0)), 42)
- self.assertAlmostEqual(complex(real = float2(17.0), imag = float2(23.0)), 17 + (0.0+23.0j))
- self.assertRaises(TypeError, complex, float2(None))
-
-
- def test_hash(self):
- for x in xrange(-30, 30):
- self.assertEqual(hash(x), hash(complex(x, 0)))
- x /= 3.0
- self.assertEqual(hash(x), hash(complex(x, 0.0)))
-
-
-
- def test_abs(self):
- nums = [ complex(x / 3.0, y / 7.0) for x in xrange(-9, 9) for y in xrange(-9, 9) ]
- for num in nums:
- self.assertAlmostEqual((num.real ** 2 + num.imag ** 2) ** 0.5, abs(num))
-
-
-
- def test_repr(self):
- self.assertEqual(repr(1 + (0.0+6.0j)), '(1+6j)')
- self.assertEqual(repr(1 - (0.0+6.0j)), '(1-6j)')
- self.assertNotEqual(repr(-(1 + (0.0+0.0j))), '(-1+-0j)')
-
-
- def test_neg(self):
- self.assertEqual(-(1 + (0.0+6.0j)), -1 - (0.0+6.0j))
-
-
- def test_file(self):
- a = 3.3300000000000001 + (0.0+4.4299999999999997j)
- b = 5.0999999999999996 + (0.0+2.2999999999999998j)
- fo = None
-
- try:
- fo = open(test_support.TESTFN, 'wb')
- print >>fo, a, b
- fo.close()
- fo = open(test_support.TESTFN, 'rb')
- self.assertEqual(fo.read(), '%s %s\n' % (a, b))
- finally:
- if fo is not None and not (fo.closed):
- fo.close()
-
-
- try:
- os.remove(test_support.TESTFN)
- except (OSError, IOError):
- pass
-
-
-
-
-
- def test_main():
- test_support.run_unittest(ComplexTest)
-
- if __name__ == '__main__':
- test_main()
-
-